/**
 * 播放队列管理系统
 * 
 * 支持五种播放内容类型：
 * 1. live_script - 直播话术（通过话术列表进行AI改写）
 * 2. time_announcement - 报时播报（手动或自动触发）
 * 3. user_interaction - 用户互动播报（自动检测触发）
 * 4. quick_broadcast - 一键用户互动（手动触发）
 * 5. ai_reply - AI智能回复（自动触发）
 */

// ==================== 类型定义 ====================

/**
 * 播放内容类型
 */
export type PlaybackContentType = 
  | 'live_script'           // 直播话术
  | 'time_announcement'     // 报时播报
  | 'user_interaction'      // 用户互动播报（自动）
  | 'quick_broadcast'       // 一键播报（手动）
  | 'ai_reply'              // AI智能回复

/**
 * 播放队列项
 */
export interface PlaybackQueueItem {
  id: string // 唯一标识
  type: PlaybackContentType // 内容类型
  originalContent: string // 原始内容
  rewrittenContent: string // AI改写后的内容
  audioData?: string // base64音频数据（可选）
  timestamp: number // 创建时间戳
}

/**
 * 回收站项（只存储已播放完成的直播话术）
 */
export interface RecycleItem {
  id: string
  type: 'live_script' // 只有直播话术才能进入回收站
  originalContent: string
  rewrittenContent: string
  audioData?: string // base64音频数据（如果有的话）
  playedAt: number // 播放完成时间戳
}

/**
 * 播放模式
 */
export type PlayMode = 'immediate' | 'next'

/**
 * 回收站配置
 */
export interface RecycleConfig {
  enable: boolean // 是否启用回收站重播
  probability: number // 重播概率（0-100）
}

// ==================== 播放队列管理器 ====================

export class PlaybackQueueManager {
  private queue: PlaybackQueueItem[] = []
  private recycleBin: RecycleItem[] = []
  private maxRecycleBinSize = 100 // 回收站最大容量
  private recycleConfig: RecycleConfig = { enable: false, probability: 0 }
  
  // 当前播放状态
  private currentPlayingItem: PlaybackQueueItem | null = null
  private isPaused = false
  
  constructor(recycleConfig?: RecycleConfig) {
    if (recycleConfig) {
      this.recycleConfig = recycleConfig
    }
  }
  
  // ==================== 队列操作 ====================
  
  /**
   * 添加项到队列末尾
   */
  enqueue(item: PlaybackQueueItem): void {
    this.queue.push(item)
  }
  
  /**
   * 添加项到队列指定位置
   * @param item 要添加的项
   * @param position 位置索引（0表示队首）
   */
  enqueueAt(item: PlaybackQueueItem, position: number): void {
    this.queue.splice(position, 0, item)
  }
  
  /**
   * 移除并返回队列第一项
   */
  dequeue(): PlaybackQueueItem | undefined {
    return this.queue.shift()
  }
  
  /**
   * 查看队列第一项（不移除）
   */
  peek(): PlaybackQueueItem | undefined {
    return this.queue[0]
  }
  
  /**
   * 获取队列长度
   */
  getQueueLength(): number {
    return this.queue.length
  }
  
  /**
   * 获取完整队列
   */
  getQueue(): PlaybackQueueItem[] {
    return [...this.queue]
  }
  
  /**
   * 清空队列
   */
  clearQueue(): void {
    this.queue = []
  }
  
  /**
   * 移除队列中的指定项
   */
  removeFromQueue(itemId: string): boolean {
    const index = this.queue.findIndex(item => item.id === itemId)
    if (index !== -1) {
      this.queue.splice(index, 1)
      return true
    }
    return false
  }
  
  // ==================== 播放控制 ====================
  
  /**
   * 设置当前播放项
   */
  setCurrentPlaying(item: PlaybackQueueItem | null): void {
    this.currentPlayingItem = item
  }
  
  /**
   * 获取当前播放项
   */
  getCurrentPlaying(): PlaybackQueueItem | null {
    return this.currentPlayingItem
  }
  
  
  /**
   * 完成当前播放
   */
  completeCurrent(): void {
    if (this.currentPlayingItem) {
      // 只有直播话术才进入回收站
      if (this.currentPlayingItem.type === 'live_script') {
        this.addToRecycleBin({
          id: this.currentPlayingItem.id,
          type: 'live_script',
          originalContent: this.currentPlayingItem.originalContent,
          rewrittenContent: this.currentPlayingItem.rewrittenContent,
          audioData: this.currentPlayingItem.audioData,
          playedAt: Date.now(),
        })
      }
      this.currentPlayingItem = null
      this.isPaused = false
    }
  }
  
  /**
   * 处理一键播报插入
   * @param item 一键播报项
   * @param playMode 播放模式
   */
  handleQuickBroadcast(item: PlaybackQueueItem, playMode: PlayMode): void {
    if (playMode === 'immediate') {
      // 立即模式：将一键播报插入队首
      this.enqueueAt(item, 0)
    } else {
      // 等待模式：插入到队列第二个位置（当前播放完成后立即播放）
      const position = this.getQueueLength() === 0 ? 0 : 1
      this.enqueueAt(item, position)
    }
  }
  
  // ==================== 回收站操作 ====================
  
  /**
   * 添加项到回收站
   */
  private addToRecycleBin(item: RecycleItem): void {
    this.recycleBin.unshift(item)
    
    // 限制回收站大小
    if (this.recycleBin.length > this.maxRecycleBinSize) {
      this.recycleBin = this.recycleBin.slice(0, this.maxRecycleBinSize)
    }
  }
  
  /**
   * 从回收站随机抽取一个项
   */
  drawFromRecycleBin(): RecycleItem | null {
    if (this.recycleBin.length === 0) {
      return null
    }
    
    const randomIndex = Math.floor(Math.random() * this.recycleBin.length)
    return this.recycleBin[randomIndex]
  }
  
  /**
   * 判断是否应该从回收站抽取（根据概率）
   */
  shouldDrawFromRecycleBin(): boolean {
    if (!this.recycleConfig.enable || this.recycleBin.length === 0) {
      return false
    }
    
    const random = Math.random() * 100
    return random < this.recycleConfig.probability
  }
  
  /**
   * 获取回收站内容
   */
  getRecycleBin(): RecycleItem[] {
    return [...this.recycleBin]
  }
  
  /**
   * 清空回收站
   */
  clearRecycleBin(): void {
    this.recycleBin = []
  }
  
  /**
   * 更新回收站配置
   */
  updateRecycleConfig(config: Partial<RecycleConfig>): void {
    this.recycleConfig = { ...this.recycleConfig, ...config }
  }
  
  /**
   * 获取回收站配置
   */
  getRecycleConfig(): RecycleConfig {
    return { ...this.recycleConfig }
  }
  
  // ==================== 统计信息 ====================
  
  /**
   * 获取队列中各类型的数量
   */
  getQueueStats(): Record<PlaybackContentType, number> {
    const stats: Record<PlaybackContentType, number> = {
      live_script: 0,
      time_announcement: 0,
      user_interaction: 0,
      quick_broadcast: 0,
      ai_reply: 0,
    }
    
    for (const item of this.queue) {
      stats[item.type]++
    }
    
    return stats
  }
  
  /**
   * 获取下一个播放项的类型
   */
  getNextItemType(): PlaybackContentType | null {
    const nextItem = this.peek()
    return nextItem ? nextItem.type : null
  }
  
  /**
   * 判断下一项是否需要间隔等待
   * 只有直播话术才需要间隔等待
   */
  shouldWaitForInterval(): boolean {
    const nextType = this.getNextItemType()
    return nextType === 'live_script'
  }
}

// ==================== 工具函数 ====================

/**
 * 生成唯一ID
 */
export function generateId(): string {
  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
}

/**
 * 创建播放队列项
 */
export function createQueueItem(
  type: PlaybackContentType,
  originalContent: string,
  rewrittenContent: string,
): PlaybackQueueItem {
  return {
    id: generateId(),
    type,
    originalContent,
    rewrittenContent,
    timestamp: Date.now(),
  }
}
